//package com.wsoft.mq.config.queue;
//
//import org.springframework.amqp.core.*;
//import org.springframework.context.annotation.Bean;
//
//import java.util.HashMap;
//import java.util.Map;
//
///**
// * @Author z001
// * @Date 2025/1/8 13:27
// */
////@Configuration
//public class QueueConfig {
//
//    /**
//     * 普通队列
//     * @return
//     */
//    @Bean
//    public Queue classicQueue() {
//        // 第二个参数表示队列是否持久化
//        return new Queue("classic_queue", false);
//    }
//
//    /**
//     * 持久化队列
//     *  持久化队列在 RabbitMQ 重启后仍然存在，消息也会被持久化到磁盘
//     * @return
//     */
//    @Bean
//    public Queue durableQueue() {
//        // 第二个参数表示队列是否持久化
//        return new Queue("durable_queue", true);
//    }
//
//    /**
//     * 独占队列
//     *  独占队列只能被一个消费者独占使用，当消费者断开连接时，队列会被自动删除
//     * @return
//     */
//    @Bean
//    public Queue exclusiveQueue() {
//        // 第三个参数表示队列是否独占
//        return new Queue("exclusive_queue", true, true, false);
//    }
//
//    /**
//     * 自动删除队列
//     *  自动删除队列在没有消费者时会被自动删除
//     * @return
//     */
//    @Bean
//    public Queue autoDeleteQueue() {
//        // 第四个参数表示队列是否自动删除
//        return new Queue("auto_delete_queue", true, false, true);
//    }
//
//    /**
//     * 惰性队列
//     *  惰性队列将消息直接存储到磁盘，而不是内存，以减少内存占用。
//     * @return
//     */
//    @Bean
//    public Queue lazyQueue() {
//        Map<String, Object> arguments = new HashMap<>(1);
//        // 指定队列模式为 lazy
//        arguments.put("x-queue-mode", "lazy");
//        return new Queue("lazy_queue", true, false, false, arguments);
//    }
//
//    /**
//     * 优先级队列
//     *  优先级队列允许消息根据优先级被消费，优先级高的消息先被处理。支持消息优先级（0-255，数字越大优先级越高）
//     */
//    @Bean
//    public Queue priorityQueue() {
//        Map<String, Object> arguments = new HashMap<>();
//        //设置最大优先级为 10
//        arguments.put("x-max-priority", 10);
//        return new Queue("priority_queue", true, false, false, arguments);
//    }
//
//    /**
//     * 流队列
//     *  流队列是 RabbitMQ 3.9.0 引入的一种新型队列，专为高吞吐量和持久化流式数据设计。
//     *  将消息存储为日志文件，支持消息的随机访问和重放。
//     * @return
//     */
//    @Bean
//    public Queue streamQueue() {
//        Map<String, Object> arguments = new HashMap<>(1);
//        // 指定队列类型为 stream
//        arguments.put("x-queue-type", "stream");
//        return new Queue("stream_queue", true, false, false, arguments);
//    }
//
//    /**
//     * 仲裁队列
//     *  仲裁队列是 RabbitMQ 3.8.0 引入的一种新型队列，基于 Raft 协议实现分布式一致性。
//     *  提供了更高的可靠性和数据安全性。
//     * @return
//     */
//    @Bean
//    public Queue quorumQueue() {
//        Map<String, Object> arguments = new HashMap<>(1);
//        //指定队列类型为 quorum
//        arguments.put("x-queue-type", "quorum");
//        return new Queue("quorum_queue", true, false, false, arguments);
//    }
//
//    //####################################  死信队列  ####################################
//
//    /**
//     * 死信队列用于存储无法被正常消费的消息（如被拒绝、过期或队列满的消息）。
//     * 它通过绑定死信交换机（Dead Letter Exchange）实现。
//     */
//
//    /**
//     *  声明死信交换机
//     * @return
//     */
//    @Bean
//    public DirectExchange deadLetterExchange() {
//        return new DirectExchange("dead_letter_exchange");
//    }
//
//    /**
//     *  声明死信队列
//     * @return
//     */
//    @Bean
//    public Queue deadLetterQueue() {
//        return new Queue("dead_letter_queue", true);
//    }
//
//    /**
//     * 绑定死信队列到死信交换机
//     * @return
//     */
//    @Bean
//    public Binding deadLetterBinding() {
//        return BindingBuilder.bind(deadLetterQueue())
//                .to(deadLetterExchange())
//                .with("dead_letter_routing_key");
//    }
//
//    /**
//     * 声明普通队列，并指定死信交换机
//     * @return
//     */
//    @Bean
//    public Queue normalQueue() {
//        Map<String, Object> arguments = new HashMap<>(2);
//        // 指定死信交换机
//        arguments.put("x-dead-letter-exchange", "dead_letter_exchange");
//        // 指定死信路由键
//        arguments.put("x-dead-letter-routing-key", "dead_letter_routing_key");
//        return new Queue("normal_queue", true, false, false, arguments);
//    }
//
//    /**
//     * 声明普通交换机
//     * @return
//     */
//    @Bean
//    public DirectExchange normalExchange() {
//        return new DirectExchange("normal_exchange");
//    }
//
//    /**
//     * 绑定普通队列到普通交换机
//     * @return
//     */
//    @Bean
//    public Binding normalBinding() {
//        return BindingBuilder.bind(normalQueue())
//                .to(normalExchange())
//                .with("normal_routing_key");
//    }
//
//
//
//    //####################################  延迟队列  ####################################
//
//    /**
//     * 延迟队列允许消息在指定的延迟时间后被消费。
//     *  在发送消息时，通过设置消息头的 x-delay 字段来指定延迟时间（单位为毫秒）。
//     *  延迟交换机的 x-delayed-type 参数决定了消息的路由方式（例如 direct、topic 等）。
//     */
//
//    /**
//     * 声明延迟交换机
//      * @return
//     */
//    @Bean
//    public CustomExchange delayedExchange() {
//        Map<String, Object> arguments = new HashMap<>(1);
//        // 指定延迟交换机的类型
//        arguments.put("x-delayed-type", "direct");
//        return new CustomExchange("delayed_exchange", "x-delayed-message", true, false, arguments);
//    }
//
//    /**
//     * 声明延迟队列
//     * @return
//     */
//    @Bean
//    public Queue delayedQueue() {
//        return new Queue("delayed_queue", true);
//    }
//
//    /**
//     * 绑定队列到延迟交换机
//     * @return
//     */
//    @Bean
//    public Binding delayedBinding() {
//        return BindingBuilder.bind(delayedQueue())
//                .to(delayedExchange())
//                .with("delayed_routing_key")
//                .noargs();
//    }
//}
